home *** CD-ROM | disk | FTP | other *** search
/ Mac-Source 1994 July / Mac-Source_July_1994.iso / C and C++ / Text⁄Files / Voyeur 1.1.1 / Voyeur ƒ / other code / Mercutio API.c next >
Text File  |  1994-02-26  |  5KB  |  151 lines
  1. // Mercutio 1.1.5 Copyright © Ramon M. Felciano, 1992 All Rights Reserved
  2.  
  3. /***********************************************************************************
  4. **
  5. **       Developer's Programming Interface for Mercutio Menu Definition Function
  6. **               © 1992 Ramon M. Felciano, All Rights Reserved
  7. **                       C port -- December 5, 1992
  8. **
  9. ************************************************************************************/
  10.  
  11. #define        customDefProcSig  'CUST'
  12. #define        areYouCustomMsg  128
  13. #define        getVersionMsg  131
  14. #define        getCopyrightMsg  132
  15. #define        mMenuKeyMsg  262
  16. #define     _Point2Long(pt)    (* (long *) &pt)            // these would have pbs with register vars
  17. #define     _Long2Point(long)    (* (Point *) &long)
  18.  
  19. void InitMercutio(void);
  20. long PowerMenuKey (long theMessage, short theModifiers, MenuHandle hMenu);
  21. Boolean IsCustomMenu (MenuHandle menu);
  22. long    GetMDEFVersion (MenuHandle menu);
  23. StringHandle    GetMDEFCopyright (MenuHandle menu);
  24.  
  25. typedef pascal void (*MDEFProc)(short msg, MenuHandle theMenu, Rect* menuRect,
  26.                 Point hitPt, short *itemID);
  27.  
  28.  
  29.  
  30. /***********************************************************************************
  31. **
  32. **   GetMDEFVersion returns the MDEF version in long form. This can be typecast
  33. **     to a normal version record if needed.
  34. **
  35. ************************************************************************************/
  36. long    GetMDEFVersion (MenuHandle menu)
  37. {
  38.     SignedByte state;
  39.     Handle    proc;
  40.     Rect    dummyRect;
  41.     short    dummyInt;
  42.     Point     pt;
  43.     
  44.     proc = (*menu)->menuProc;    /* same as **menu.menuProc */
  45.     state = HGetState(proc);
  46.     HLock(proc);
  47.     dummyRect.top = dummyRect.left = dummyRect.bottom = dummyRect.right = 0;
  48.  
  49.     SetPt(&pt,0,0);
  50.     ((MDEFProc) *proc)(getVersionMsg, menu, &dummyRect, pt, &dummyInt);
  51.     HSetState(proc, state);
  52.     
  53.     /* the result, a long, is returned in dummyRect.topLeft */
  54.     return _Point2Long(topLeft(dummyRect));
  55. }
  56.  
  57. /***********************************************************************************
  58. **
  59. **   GetMDEFCopyright returns a stringHandle to the copyright message for the MDEF.
  60. **
  61. **   IMPORTANT: THE CALLER IS RESPONSIBLE FOR DISPOSING OF THIS HANDLE WHEN DONE
  62. **              WITH IT.
  63. **
  64. ************************************************************************************/
  65. StringHandle    GetMDEFCopyright (MenuHandle menu)
  66. {
  67.     SignedByte state;
  68.     Handle    proc;
  69.     Rect    dummyRect;
  70.     short    dummyInt;
  71.     Point     pt;
  72.     
  73.     proc = (*menu)->menuProc;    /* same as **menu.menuProc */
  74.     state = HGetState(proc);
  75.     HLock(proc);
  76.     dummyRect.top = dummyRect.left = dummyRect.bottom = dummyRect.right = 0;
  77.  
  78.     SetPt(&pt,0,0);
  79.     ((MDEFProc) *proc)(getCopyrightMsg, menu, &dummyRect, pt, &dummyInt);
  80.     HSetState(proc, state);
  81.     
  82.     /* the result, a stringHandle, is returned in dummyRect.topLeft */
  83.     return *(StringHandle*)(&dummyRect);
  84. }
  85.  
  86. /***********************************************************************************
  87. **
  88. **   IsCustomMenu returns true if hMenu is controlled by a custom MDEF. This relies on my}
  89. **   convention of returning the customDefProcSig constant in the rect parameter: this obtuse}
  90. **   convention should be unique enough that only my custom MDEFs behave this way.}
  91. **
  92. ************************************************************************************/
  93. Boolean IsCustomMenu (MenuHandle menu)
  94. {
  95.     SignedByte state;
  96.     Handle    proc;
  97.     Rect    dummyRect;
  98.     short    dummyInt;
  99.     Point     pt;
  100.     
  101.     proc = (*menu)->menuProc;    /* same as **menu.menuProc */
  102.     state = HGetState(proc);
  103.     HLock(proc);
  104.     dummyRect.top = dummyRect.left = dummyRect.bottom = dummyRect.right = 0;
  105.  
  106.     SetPt(&pt,0,0);
  107.     ((MDEFProc) *proc)(areYouCustomMsg, menu, &dummyRect, pt, &dummyInt);
  108.     HSetState(proc, state);
  109.     
  110.     /* the result, a long, is returned in dummyRect.topLeft */
  111.     return (_Point2Long(topLeft(dummyRect)) == (long) (customDefProcSig));
  112. }
  113.  
  114.  
  115. /***********************************************************************************
  116. **
  117. **   PowerMenuKey is a replacement for the standard toolbox call MenuKey for use with the}
  118. **   Mercutio. Given the keypress message and modifiers parameters from a standard event, it }
  119. **   checks to see if the keypress is a key-equivalent for a particular menuitem. If you are currently}
  120. **   using custom menus (i.e. menus using Mercutio), pass the handle to one of these menus in}
  121. **   hMenu. If you are not using custom menus, pass in NIL or another menu, and PowerMenuKey will use the}
  122. **   standard MenuKey function to interpret the keypress.}
  123. **
  124. **   As with MenuKey, PowerMenuKey returns the menu ID in high word of the result, and the menu}
  125. **   item in the low word.}
  126. **
  127. ************************************************************************************/
  128.  
  129. long PowerMenuKey (long theMessage, short theModifiers, MenuHandle hMenu)
  130. {
  131.     if ((hMenu == NULL) || (!IsCustomMenu(hMenu)))
  132.     {
  133.         return(MenuKey((char)(theMessage & charCodeMask)));
  134.     }
  135.     else
  136.     {
  137.         Handle proc = (*hMenu)->menuProc;
  138.         char state = HGetState(proc);
  139.         Rect dummyRect;
  140.         Point pt = _Long2Point(theMessage);
  141.         
  142.         HLock(proc);
  143.         dummyRect.top = dummyRect.left = 0;
  144.         ((MDEFProc) *proc)(mMenuKeyMsg, hMenu, &dummyRect, pt, &theModifiers);
  145.         HSetState(proc, state);
  146.         return( _Point2Long(topLeft(dummyRect)));
  147.     }
  148. }
  149.  
  150.  
  151.